home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / bnchmark.arc / BMARK.NEC
Encoding:
Text File  |  1985-12-08  |  15.5 KB  |  464 lines
  1. 12:25:31  12/8/1985
  2.  
  3. I recently decided (for myself, at least) to settle the question of how
  4. much speed increase one could expect from the addition of a NEC V series
  5. chip to an IBM PC (or compatible) computer.  I was mainly concerned with
  6. the type of operations that I might do on a regular basis.  For the sake of
  7. completeness, I included some of the BYTE benchmarks.
  8.  
  9. All tests were performed on the same computer (AT&T 6300), the same hard
  10. drive (Syquest 306R - 5 meg removable), with the same ram resident software
  11. loaded.  The hard drive was returned to original condition after any test
  12. that wrote to the drive.
  13.  
  14. Timings were kept using a program called TIMER.COM from Leroy Casterline.
  15. It seems to be accurate to .05 seconds.
  16.  
  17.                                ARCHIVE TEST
  18.  
  19. Using ARC version 4.5, 19 files with a total size of 1,018,271 bytes were
  20. archived.  Test files follow:
  21.  
  22. .           <DIR>   06Dec85 21:54         PIBTERM .007   4608 09Nov85 03:41
  23. ..          <DIR>   06Dec85 21:54         PIBTERM .COM  37592 09Nov85 03:42
  24. APP2_1  .EXE  41380 17Jun85 14:46         PIBTERM .FON  10001 08Oct85 03:30
  25. APPFILE .DOC   6005 19Jun85 18:37         QMOD112 .000  50688 16Nov85 12:03
  26. PIBTERM .000  80128 09Nov85 03:35         QMOD112 .COM  45811 16Nov85 12:04
  27. PIBTERM .001  25088 09Nov85 03:20         QMOD112 .DOC  54400 17Nov85 16:21
  28. PIBTERM .002  26624 09Nov85 03:26         REFLEX  .EXE 267420 15Jun85 17:04
  29. PIBTERM .003  10752 09Nov85 03:32         REFLEX2 .EXE 260715 16Oct85 14:58
  30. PIBTERM .004  15616 09Nov85 03:31         XPC2_1  .COM  39842 19Jun85 13:50
  31. PIBTERM .005  20736 09Nov85 03:42         XPCFILE .DOC   9089 19Jun85 18:37
  32. PIBTERM .006  11776 09Nov85 03:40
  33.      1018271 Bytes in       21 File(s);      1060864 bytes free.
  34.  
  35.  
  36. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  37. INTEL 8086    1        32:49.35            32.49.35
  38. NEC V30        1        27:23.26            27.23.26
  39.  
  40. INCREASE DUE TO NEC V30 CHIP -- 16.56%
  41.  
  42.  
  43.  
  44.                       LUU (LIBRARY AND SQUEEZE) TEST 
  45.  
  46. Using LUU 2.1, the same 19 files with a total size of 1,018,271 bytes were
  47. libraried and squeezed.
  48.  
  49. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  50. INTEL 8086    2        5:25.22,5:25.0                  5:25.11
  51. NEC V30         3               5:02.64,5:05.44,5:06.71         5:04.93
  52.  
  53. INCREASE DUE TO NEC V30 CHIP -- 6.21%
  54.  
  55.  
  56.            AZTEC C COMPILE, ASSEMBLE, AND LINK USING A MAKE FILE
  57.  
  58. A 21k .exe file was generated from 10 independently compiled and assembled 
  59. modules.  All environmental variables remained constant throughout the 
  60. tests.
  61.  
  62. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  63. INTEL 8086    2        2:55.98,2:54.72                 2:55.35
  64. NEC V30         2               2:49.5,2:47.97                  2:48.735
  65.  
  66. INCREASE DUE TO NEC V30 CHIP -- 3.77%
  67.  
  68.  
  69.                            DBASE III INDEX TEST
  70.  
  71. Using version 1.1 of Ashton Tate's Dbase III, a 1,170,579 byte .dbf file
  72. was indexed on a concatenated string using the following program:
  73.  
  74. ? time()
  75. use monthly
  76. index on str(tag,7,4)+dtoc(date_comp) to test
  77. ? time()
  78. close data
  79.  
  80. The structure for the monthly file follows:
  81.  
  82. Structure for database : monthly.dbf
  83. Number of data records :      15000
  84. Date of last update    : 12-06-1985
  85. Field  Field name  Type       Width    Dec
  86. -----  ----------  ----       -----    ---
  87.     1  TAG         Numeric        7      4
  88.     2  DATE_COMP   Date           8
  89.     3  PARTS       Numeric        6      2
  90.     4  PART_TYPE   Character      2
  91.     5  TAX         Numeric        5      2
  92.     6  LABOR       Numeric        6      2
  93.     7  LABR_TYPE   Character      2
  94.     8  SERV_SUPL   Numeric        5      2
  95.     9  SHIPPING    Numeric        5      2
  96.    10  SHIP_TYPE   Character      2
  97.    11  OTHER       Numeric        5      2
  98.    12  OTHR_TYPE   Character      2
  99.    13  TECH        Numeric        3      0
  100.    14  DELVR_TO    Numeric        2      0
  101.    15  FLAG        Character      2
  102.    16  BRAND       Character     12
  103.    17  UNIT_TYPE   Character      3
  104. ** Total **                      78
  105.  
  106.  
  107. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  108. INTEL 8086    1        1:36:49.0                       1:36.49.0
  109. NEC V30         1               1:32:58.0                       1:32:58.0
  110.  
  111. INCREASE DUE TO NEC V30 CHIP -- 3.98%
  112.  
  113.  
  114.                             BASIC COMPILER TEST
  115.  
  116. Using IBM's Basic Compiler version 1.0, RBBS5A (w/B9 merges) was compiled 
  117. as per the instructions in the documentation for the B9 merges from Mark 
  118. Seiden.
  119.  
  120. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  121. INTEL 8086    2        3:25.64,3:23.94                 3:24.79
  122. NEC V30         3               3:09.66,2:59.5,3:14.5           3:07.88
  123.  
  124. INCREASE DUE TO NEC V30 CHIP -- 8.25%
  125.  
  126.  
  127.                                  LINK TEST
  128.  
  129. Using the IBM Personal Computer Linker version 2.2, the RBBS .obj file was 
  130. linked with the supporting modules to create an .exe file.
  131.  
  132. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  133. INTEL 8086    2        2:03.75,2:03.97                 2:03.86
  134. NEC V30         3               1:48.48,1:47.71,1:47.98         1:48.06
  135.  
  136. INCREASE DUE TO NEC V30 CHIP -- 12.76%
  137.  
  138.                               SIEVE TEST IN C
  139.  
  140. The following sieve test was taken from the Byte Benchmarks and the source 
  141. code follows:
  142.  
  143. /*
  144.  *              UNIX Operating Sytem Implementation Test #4
  145.  *
  146.  *      "Benchmarking UNIX Systems", BYTE magazine August 1984
  147.  *
  148.  *  No benchmark suite would be complete without the ever-popular
  149.  *  sieve benchmark.  It is a good test of compiler efficiency and
  150.  *  CPU throughput.  Below is a sieve benchmark as presented in the
  151.  *  January 1983 issue of BYTE, with some other minor changes: Register
  152.  *  declarations have been added, and some unnecessary (from our
  153.  *  standpoint) printf() statements removed.
  154.  *
  155.  *  Instructions:
  156.  *      Compile by:             cc -O -s -o sieve sieve.c
  157.  *
  158.  *              The -O option says to use the optimizer.
  159.  *              The -s option says to strip the namelist from the
  160.  *                      object file after linking.
  161.  *              The -o option says to place the oblect file in the file
  162.  *                      specified by the next argument.
  163.  *
  164.  *      Time by:                /bin/time sieve
  165.  *
  166.  *      Results:
  167.  *              In the past, the elapsed time has been used, since most
  168.  *              operating systems can measure real time.  Actually, user
  169.  *              time is a better value.
  170.  *
  171.  */
  172.  
  173. /* Eratosthenes Sieve Prime Number program in C */
  174. #define TRUE    1
  175. #define FALSE   0
  176. #define SIZE    8190
  177.  
  178. char flags[SIZE + 1];
  179.  
  180. main() {
  181.         register int i, prime, k, count, iter;
  182. /*      printf("10 iterations\n"); */           /* We don't need this */
  183.         for (iter = 1; iter <= 10; iter++) {    /* do program 10 times */
  184.                 count = 0;                      /* prime counter */
  185.                 for (i = 0; i <= SIZE; i++)     /* set all flags TRUE */
  186.                         flags[i] = TRUE;
  187.                 for (i = 0; i <= SIZE; i++) {
  188.                         if (flags[i]) {         /* found a prime */
  189.                                 prime = i + i + 3; /* twice index + 3 */
  190. /*                              printf("\n%d", prime); */ /* nor this */
  191.                                 for (k = i + prime; k <= SIZE; k += prime)
  192.                                         flags[k] = FALSE; /* kill all multiples */
  193.                                 count++;        /* primes found */
  194.                         }
  195.                 }
  196.         }
  197. /*      printf("\n%d primes.",, count); */      /* primes found on tenth pass */
  198. }
  199.  
  200.  
  201. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  202. INTEL 8086    4        4.6,4.7,4.1,4.1                 4.375
  203. NEC V30         4               3.41,3.41,3.35,3.30             3.3675
  204.  
  205. INCREASE DUE TO NEC V30 CHIP -- 23.03%
  206.  
  207.  
  208.                            EMPTY LOOP TEST IN C
  209.  
  210. Another Byte test with the following source code:
  211.  
  212. /*
  213.  *              UNIX Operating Sytem Implementation Test #7
  214.  *
  215.  *      "Benchmarking UNIX Systems", BYTE magazine August 1984
  216.  *
  217.  *  This program tests long integer incrementation.  It is
  218.  *  taken from USENET news article "megatest.186".
  219.  *
  220.  *  Instructions:
  221.  *      Compile by:             cc -O -s -o loop loop.c
  222.  *
  223.  *              The -O option says to use the optimizer.
  224.  *              The -s option says to strip the namelist from the
  225.  *                      object file after linking.
  226.  *              The -o option says to place the oblect file in the file
  227.  *                      specified by the next argument.
  228.  *
  229.  *      Time by:                /bin/time loop
  230.  *
  231.  *      Results:
  232.  *              Altough not very significant, it does say something about the
  233.  *              speed of the processor, since the compiler would hopefully
  234.  *              compile the "i++" as an INCR instruction and not an ADD
  235.  *              instruction.  The benchmark is presented here for historical
  236.  *              reasons.
  237.  *
  238.  */
  239.  
  240. main() {
  241.         long i;
  242.         for (i = 0; i < 1000000; i++)
  243.                 ;
  244.         printf("Done\n");
  245. }
  246.  
  247.  
  248. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  249. INTEL 8086    4        16.37,16.37,16.36,16.31         16.3525
  250. NEC V30         4               14.23,14.23,14.17,14.23         14.215
  251.  
  252. INCREASE DUE TO NEC V30 CHIP -- 13.07%
  253.  
  254.  
  255.                         FCALL1 - FUNCTION CALL IN C
  256.  
  257. Another Byte Benchmark with the source code that follows:
  258.  
  259. /*
  260.  *              UNIX Operating Sytem Implementation Test #3
  261.  *
  262.  *      "Benchmarking UNIX Systems", BYTE magazine August 1984
  263.  *
  264.  *  This program enables precise arithmetic calculations of user function
  265.  *  overhead by subtracting the execution user time when compiled without
  266.  *  using a function from execution user time using a function.
  267.  *
  268.  *  Instructions:
  269.  *      Compile by:             cc -O -DEMPTY -s -o fcalle fcall.c
  270.  *              and
  271.  *                              cc -O -DASSIGN -s -o fcalla fcall.c
  272.  *
  273.  *              The -O option says to use the optimizer.
  274.  *              The -s option says to strip the namelist from the
  275.  *                      object file after linking.
  276.  *              The -o option says to place the oblect file in the file
  277.  *                      specified by the next argument.
  278.  *
  279.  *      Time by:                /bin/time fcalle
  280.  *              and
  281.  *                              /bin/time fcalla
  282.  *
  283.  *      Results:
  284.  *              Since the user time is more accurate than the real time
  285.  *              and since system time effectively does not contribute to
  286.  *              the real time number, we can use the difference between
  287.  *              the user times in seconds as an accurate numerical account
  288.  *              of the function call overhead.
  289.  *
  290.  */
  291.  
  292. #define TIMES 50000
  293.  
  294. main()
  295.         /* the first way of doing things - use a function call */
  296. #ifdef EMPTY
  297. {
  298.         register unsigned int i, j;
  299.         for (i = 0; i < TIMES; i++)
  300.                 j = empty(i);
  301. }
  302.  
  303.         /* the empty function */
  304. empty(k)
  305. register unsigned int k;
  306. {
  307.         return(k);
  308. }
  309. #endif
  310.  
  311.  
  312. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  313. INTEL 8086    4        1.82,1.81,1.75,1.76             1.785
  314. NEC V30         4               1.70,1.70,1.70,1.71             1.7025
  315.  
  316. INCREASE DUE TO NEC V30 CHIP -- 4.62%
  317.  
  318.  
  319.                   FCALL2 - FUNCTION CALL IN C ANOTHER WAY
  320.  
  321.  
  322. Yet another Byte Benchmark -- source follows:
  323.  
  324. /*
  325.  *              UNIX Operating Sytem Implementation Test #3
  326.  *
  327.  *      "Benchmarking UNIX Systems", BYTE magazine August 1984
  328.  *
  329.  *  This program enables precise arithmetic calculations of user function
  330.  *  overhead by subtracting the execution user time when compiled without
  331.  *  using a function from execution user time using a function.
  332.  *
  333.  *  Instructions:
  334.  *      Compile by:             cc -O -DEMPTY -s -o fcalle fcall.c
  335.  *              and
  336.  *                              cc -O -DASSIGN -s -o fcalla fcall.c
  337.  *
  338.  *              The -O option says to use the optimizer.
  339.  *              The -s option says to strip the namelist from the
  340.  *                      object file after linking.
  341.  *              The -o option says to place the oblect file in the file
  342.  *                      specified by the next argument.
  343.  *
  344.  *      Time by:                /bin/time fcalle
  345.  *              and
  346.  *                              /bin/time fcalla
  347.  *
  348.  *      Results:
  349.  *              Since the user time is more accurate than the real time
  350.  *              and since system time effectively does not contribute to
  351.  *              the real time number, we can use the difference between
  352.  *              the user times in seconds as an accurate numerical account
  353.  *              of the function call overhead.
  354.  *
  355.  */
  356.  
  357. #define TIMES 50000
  358.  
  359. main()
  360. #ifdef ASSIGN
  361.         /* the second way of doing things - without a function call */
  362. {
  363.         register unsigned int i, j;
  364.         for (i = 0; i < TIMES; i++)
  365.                 j = i;
  366. }
  367. #endif
  368.  
  369. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  370. INTEL 8086    4        .66,.66,.66,.66                 .66
  371. NEC V30         4               .60,.54,.61,.55                 .575
  372.  
  373. INCREASE DUE TO NEC V30 CHIP -- 12.88%
  374.  
  375.  
  376.                        CALC TEST IN BASIC (compiled)
  377.  
  378. Another Byte Benchmark -- source follows:
  379.  
  380. 5 REM: the calculation benchmark
  381. 10 NR = 5000
  382. 20 DEFSNG A-Z
  383. 30 A = 2.71828
  384. 40 B = 3.14159
  385. 50 C = 1
  386. 60 FOR I = 1 TO NR
  387. 70 C = C * A
  388. 80 C = C * B
  389. 90 C = C / A
  390. 100 C = C / B
  391. 110 NEXT I
  392. 120 PRINT "done"
  393. 130 PRINT "error = "; C - 1
  394.  
  395.  
  396. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  397. INTEL 8086    4        5.76,5.66,5.72,5.66             5.7
  398. NEC V30         5               4.39,4.45,4.34,4.34,4.34        4.372
  399.  
  400. INCREASE DUE TO NEC V30 CHIP -- 23.3%
  401.  
  402.  
  403.                       SIEVE TEST IN BASIC (compiled)
  404.  
  405. Another Byte Benchmark -- source follows:
  406.  
  407. 5 REM: the sieve benchmark
  408. 10 SIZE = 7000
  409. 20 DIM FLAGS(7001)
  410. 30 PRINT "start one iteration"
  411. 40 COUNT = 0
  412. 50 FOR I = 0 TO SIZE
  413. 60 FLAGS(I) = 1
  414. 70 NEXT I
  415. 80 FOR I = 0 TO SIZE
  416. 90 IF FLAGS(I) = 0 THEN 170
  417. 100 PRIME = I + I + 3
  418. 110 K = I + PRIME
  419. 120 IF K > SIZE THEN 160
  420. 130 FLAGS(K) = 0
  421. 140 K = K + PRIME
  422. 150 GOTO 120
  423. 160 COUNT = COUNT + 1
  424. 170 NEXT I
  425. 180 PRINT "done: "; COUNT; " primes found"
  426.  
  427.  
  428. CHIP        # TEST RUNS    TIMINGS    (HRS:MINS:SECS.XX)    AVERAGE
  429. INTEL 8086    4        9.18,9.6,9.1,9.6                9.37
  430. NEC V30         4               8.24,8.13,8.13,8.13             8.1575
  431.  
  432. INCREASE DUE TO NEC V30 CHIP -- 12.94%
  433.  
  434.  
  435.                                   SUMMARY
  436.  
  437. The final average results over 12 tests show a net increase in speed 
  438. attributable to the NEC V series chip of 11.78%
  439.  
  440. Should you install the chip in your computer?  Take a close look at the 
  441. individual test results.  If an operation you perform often would benefit 
  442. from the chip, then by all means, add it to your system.  I am told that 
  443. Lotus and other spreadsheets will recalculate somewhere between 20% and 40% 
  444. faster on the NEC chip.  I could not test this claim.
  445.  
  446. I found it very interesting that the LUU program took only 5 mins+ to lib 
  447. and squeeze 1.1 megs, but the ARC program took 27-32 minutes.  The ARC'd 
  448. file showed a space savings of only some 29K.  Not such a good return for 
  449. the extra 25 minutes.
  450.  
  451. All the C programs were compiled with Aztec C version 2.20d.
  452.  
  453. These tests performed courtesy of TERRAPIN STATION BBS in Minneapolis, MN.
  454. A BBS for programmers and technically oriented folk!
  455. 24 hours a day -- 1200/2400
  456. 612/623-0152
  457.  
  458. Beta test site and authorized dealer for MultiTech modems.
  459. We sell the NEC chips and assorted other esoteric hardware and software.
  460. See bulletin #8 when you log in.
  461.  
  462. Howard Ekman
  463. Sysop -- Terrapin Station BBS
  464.